import { DatabaseCore } from './core.js';
import { DatabaseMigration } from './migration.js';
import { TransactionsManager } from './transactions.js';
import { RulesManager } from './rules.js';

/**
 * 数据库管理器
 * 整合所有数据库模块的主入口
 */
export class DatabaseManager {
  constructor(dbPath = 'network-firewall.db') {
    // 初始化核心数据库
    this.core = new DatabaseCore(dbPath);
    
    // 初始化迁移管理器
    this.migration = new DatabaseMigration(this.core);
    
    // 初始化业务管理器
    this.transactions = new TransactionsManager(this.core);
    this.rules = new RulesManager(this.core);
    
    // 执行数据库迁移
    this.init();
  }

  /**
   * 初始化数据库
   */
  init() {
    try {
      // 执行数据库迁移
      this.migration.migrate();
      console.log('📚 数据库管理器初始化完成');
    } catch (error) {
      console.error('❌ 数据库管理器初始化失败:', error.message);
      throw error;
    }
  }

  // ===========================================
  // 事务相关方法 - 委托给 TransactionsManager
  // ===========================================

  /**
   * 保存完整的事务记录
   */
  saveTransaction(transaction) {
    return this.transactions.saveTransaction(transaction);
  }

  /**
   * 获取事务列表
   */
  getTransactions(limit = 100, offset = 0) {
    return this.transactions.getTransactions(limit, offset);
  }

  /**
   * 获取单个事务
   */
  getTransaction(id) {
    return this.transactions.getTransaction(id);
  }

  /**
   * 获取事务统计信息
   */
  getTransactionStats() {
    return this.transactions.getTransactionStats();
  }

  /**
   * 清理旧事务
   */
  cleanup(daysToKeep = 30) {
    return this.transactions.cleanupOldTransactions(daysToKeep);
  }

  // ===========================================
  // 规则相关方法 - 委托给 RulesManager
  // ===========================================

  /**
   * 保存规则
   */
  saveRule(rule) {
    return this.rules.saveRule(rule);
  }

  /**
   * 获取所有规则
   */
  getRules() {
    return this.rules.getRules();
  }

  /**
   * 获取启用的规则
   */
  getEnabledRules() {
    return this.rules.getEnabledRules();
  }

  /**
   * 获取单个规则
   */
  getRule(id) {
    return this.rules.getRule(id);
  }

  /**
   * 删除规则
   */
  deleteRule(id) {
    return this.rules.deleteRule(id);
  }

  /**
   * 更新规则状态
   */
  updateRuleStatus(id, enabled) {
    return this.rules.updateRuleStatus(id, enabled);
  }

  /**
   * 导入规则
   */
  importRules(rules) {
    return this.rules.importRules(rules);
  }

  /**
   * 导出规则
   */
  exportRules() {
    return this.rules.exportRules();
  }

  /**
   * 搜索规则
   */
  searchRules(searchOptions) {
    return this.rules.searchRules(searchOptions);
  }

  /**
   * 获取规则统计信息
   */
  getRuleStats() {
    return this.rules.getRuleStats();
  }

  /**
   * 复制规则
   */
  duplicateRule(ruleId, newName) {
    return this.rules.duplicateRule(ruleId, newName);
  }

  // ===========================================
  // 综合方法 - 组合多个管理器
  // ===========================================

  /**
   * 获取完整的统计信息
   */
  getStats() {
    try {
      // 组合所有统计信息
      const transactionStats = this.transactions.getTransactionStats();
      const ruleStats = this.rules.getRuleStats();
      const coreStats = this.core.getStats();

      return {
        ...coreStats,
        transactions: transactionStats,
        rules: ruleStats,
        generatedAt: Date.now()
      };
    } catch (error) {
      console.error('❌ 获取统计信息失败:', error.message);
      return {};
    }
  }

  /**
   * 清空所有记录
   */
  clearAllRecords() {
    try {
      const clearTransaction = this.core.transaction(() => {
        // 清空所有事务
        this.transactions.clearAllTransactions();
        
        // 可选择是否清空规则（通常不清空）
        // this.rules.clearAllRules();
      });

      clearTransaction();
      console.log('📚 已清空所有记录');
      return true;
    } catch (error) {
      console.error('❌ 清空记录失败:', error.message);
      return false;
    }
  }

  /**
   * 数据库维护操作
   */
  maintenance() {
    try {
      console.log('📚 开始数据库维护...');
      
      // 执行数据库分析
      this.core.analyze();
      console.log('  ✅ 数据库分析完成');
      
      // 执行真空操作
      this.core.vacuum();
      console.log('  ✅ 数据库压缩完成');
      
      // 检查数据库完整性
      const isIntegrityOk = this.core.checkIntegrity();
      if (isIntegrityOk) {
        console.log('  ✅ 数据库完整性检查通过');
      } else {
        console.warn('  ⚠️ 数据库完整性检查失败');
      }
      
      console.log('📚 数据库维护完成');
      return { success: true, integrity: isIntegrityOk };
    } catch (error) {
      console.error('❌ 数据库维护失败:', error.message);
      return { success: false, error: error.message };
    }
  }

  /**
   * 导出数据库
   */
  exportDatabase() {
    try {
      const exportData = {
        exportedAt: Date.now(),
        version: '1.0',
        migration: this.migration.getMigrationHistory(),
        rules: this.rules.exportRules(),
        stats: this.getStats()
      };

      console.log('📚 数据库导出完成');
      return exportData;
    } catch (error) {
      console.error('❌ 数据库导出失败:', error.message);
      return null;
    }
  }

  /**
   * 获取数据库信息
   */
  getInfo() {
    try {
      const coreInfo = this.core.getInfo();
      const migrationInfo = this.migration.getMigrationHistory();
      const tables = this.core.getAllTables();

      return {
        ...coreInfo,
        migration: migrationInfo,
        tables: tables,
        modules: {
          core: 'DatabaseCore',
          migration: 'DatabaseMigration',
          transactions: 'TransactionsManager',
          rules: 'RulesManager'
        }
      };
    } catch (error) {
      console.error('❌ 获取数据库信息失败:', error.message);
      return null;
    }
  }

  // ===========================================
  // 核心数据库方法 - 委托给 DatabaseCore
  // ===========================================

  /**
   * 关闭数据库连接
   */
  close() {
    this.core.close();
  }

  /**
   * 获取原始数据库实例（谨慎使用）
   */
  getRawDatabase() {
    return this.core.getRawDatabase();
  }

  // ===========================================
  // 向后兼容方法
  // ===========================================

  /**
   * @deprecated 使用 migration.migrate() 替代
   */
  migrateDatabase() {
    console.warn('⚠️ migrateDatabase() 已废弃，请使用 migration.migrate()');
    return this.migration.migrate();
  }
} 